const express = require('express');
const multer = require('multer'); // 用于处理文件上传的中间件
const path = require('path');
const fs = require('fs');
const Pet = require('../models/pet'); // 引入宠物模型
const { authMiddleware, adminMiddleware } = require('../middleware/auth'); // 引入认证中间件
const { pool } = require('../config/db'); // 引入数据库连接池

const router = express.Router();

// 配置multer用于文件上传
const storage = multer.diskStorage({
  // 设置上传文件的存储目录
  destination: (req, file, cb) => {
    const uploadDir = path.join(__dirname, '../uploads');
    // 如果目录不存在则创建
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }
    cb(null, uploadDir);
  },
  // 自定义文件名，保证唯一性
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    const fileExt = path.extname(file.originalname);
    cb(null, 'pet-' + uniqueSuffix + fileExt);
  }
});

// 文件类型过滤器
const fileFilter = (req, file, cb) => {
  const allowedTypes = /jpeg|jpg|png|gif/;
  const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
  const mimetype = allowedTypes.test(file.mimetype);

  // 只允许上传图片文件
  if (extname && mimetype) {
    return cb(null, true);
  } else {
    cb(new Error('只允许上传图片文件!'));
  }
};

// 初始化上传配置
const upload = multer({
  storage,
  limits: { fileSize: 5 * 1024 * 1024 }, // 5MB 大小限制
  fileFilter
});

// @route   GET api/pets
// @desc    获取所有宠物列表，支持分页和过滤
// @access  公开访问
router.get('/', async (req, res) => {
  try {
    // 从查询参数中获取过滤条件
    const { page = 1, limit = 10, category_id, gender, size, is_adopted, q } = req.query;
    
    // 构造过滤条件对象
    const filters = {};
    
    // 只添加有值的过滤条件
    if (category_id) filters.category_id = parseInt(category_id);
    if (gender) filters.gender = gender;
    if (size) filters.size = size;
    if (q) filters.search = q;
    
    // 将is_adopted字符串转换为布尔值
    if (is_adopted !== undefined) {
      filters.is_adopted = is_adopted === 'true';
    }
    
    // 调用模型方法获取宠物列表
    const result = await Pet.findAll(parseInt(page), parseInt(limit), filters);
    
    // 确保返回的数据格式正确
    if (!result.pets) {
      result.pets = [];
    }
    
    if (!result.pagination) {
      result.pagination = {
        total: 0,
        page: parseInt(page),
        limit: parseInt(limit),
        totalPages: 0
      };
    }
    
    res.json(result);
  } catch (err) {
    console.error('获取宠物列表失败:', err);
    res.status(500).json({ message: '服务器错误' });
  }
});

// @route   GET api/pets/categories
// @desc    获取所有宠物类别
// @access  公开访问
router.get('/categories', async (req, res) => {
  try {
    // 获取所有宠物类别
    const categories = await Pet.getCategories();
    res.json(categories);
  } catch (err) {
    console.error(err.message);
    res.status(500).send('服务器错误');
  }
});

// @route   GET api/pets/count
// @desc    获取宠物总数
// @access  公开访问
router.get('/count', async (req, res) => {
  try {
    // 获取宠物总数
    const count = await Pet.getCount();
    res.json({ count });
  } catch (err) {
    console.error('获取宠物总数失败:', err.message);
    res.status(500).json({ message: '服务器错误' });
  }
});

// @route   GET api/pets/category/:id
// @desc    获取特定类别下的宠物
// @access  公开访问
router.get('/category/:id', async (req, res) => {
  try {
    // 从查询参数中获取分页信息
    const { page = 1, limit = 10 } = req.query;
    // 获取指定类别的宠物
    const result = await Pet.findByCategory(req.params.id, page, limit);
    res.json(result);
  } catch (err) {
    console.error(err.message);
    res.status(500).send('服务器错误');
  }
});

// @route   GET api/pets/:id
// @desc    通过ID获取宠物详情
// @access  公开访问
router.get('/:id', async (req, res) => {
  try {
    // 获取指定ID的宠物
    const pet = await Pet.findById(req.params.id);
    
    // 如果宠物不存在，返回404错误
    if (!pet) {
      return res.status(404).json({ message: '找不到宠物' });
    }
    
    res.json(pet);
  } catch (err) {
    console.error(err.message);
    res.status(500).send('服务器错误');
  }
});

// @route   POST api/pets
// @desc    创建新宠物
// @access  私有 (仅限管理员)
router.post('/', [authMiddleware, adminMiddleware, upload.single('image')], async (req, res) => {
  try {
    // 从请求体获取宠物信息
    const {
      name,
      category_id,
      breed,
      age,
      gender,
      size,
      description,
      health_status,
      behavior
    } = req.body;

    // 创建宠物数据对象
    const petData = {
      name,
      category_id,
      breed,
      age,
      gender,
      size,
      description,
      health_status,
      behavior,
      image_url: req.file ? `/uploads/${req.file.filename}` : null // 如果上传了图片，保存图片路径
    };

    // 创建宠物记录
    const pet = await Pet.create(petData);
    res.status(201).json(pet);
  } catch (err) {
    console.error(err.message);
    res.status(500).send('服务器错误');
  }
});

// @route   PUT api/pets/:id
// @desc    更新宠物信息
// @access  私有 (仅限管理员)
router.put('/:id', [authMiddleware, adminMiddleware, upload.single('image')], async (req, res) => {
  try {
    // 获取要更新的宠物
    const pet = await Pet.findById(req.params.id);
    
    // 如果宠物不存在，返回404错误
    if (!pet) {
      return res.status(404).json({ message: '找不到宠物' });
    }

    // 从请求体获取更新的字段
    const {
      name,
      category_id,
      breed,
      age,
      gender,
      size,
      description,
      health_status,
      behavior,
      is_adopted
    } = req.body;

    // 创建更新数据对象，保留原有值或使用新值
    const petData = {
      name: name || pet.name,
      category_id: category_id || pet.category_id,
      breed: breed || pet.breed,
      age: age || pet.age,
      gender: gender || pet.gender,
      size: size || pet.size,
      description: description || pet.description,
      health_status: health_status || pet.health_status,
      behavior: behavior || pet.behavior,
      is_adopted: is_adopted !== undefined
        ? (is_adopted === 'true' || is_adopted === true || is_adopted === 1 || is_adopted === '1' ? 1 : 0)
        : pet.is_adopted,
      image_url: req.file ? `/uploads/${req.file.filename}` : pet.image_url // 如果上传了新图片，更新图片路径
    };

    // 更新宠物信息
    const updatedPet = await Pet.update(req.params.id, petData);
    res.json(updatedPet);
  } catch (err) {
    console.error(err.message);
    res.status(500).send('服务器错误');
  }
});

// @route   DELETE api/pets/:id
// @desc    删除宠物
// @access  私有 (仅限管理员)
router.delete('/:id', [authMiddleware, adminMiddleware], async (req, res) => {
  try {
    // 获取要删除的宠物
    const pet = await Pet.findById(req.params.id);
    
    // 如果宠物不存在，返回404错误
    if (!pet) {
      return res.status(404).json({ message: '找不到宠物' });
    }

    // Note: We no longer need to manually delete adoption applications
    // as we're using ON DELETE CASCADE in the database schema
    // The related applications will be automatically deleted when the pet is deleted

    // 如果宠物有图片，删除图片文件
    if (pet.image_url) {
      try {
        const imagePath = path.join(__dirname, '..', pet.image_url);
        if (fs.existsSync(imagePath)) {
          fs.unlinkSync(imagePath);
          console.log(`已删除宠物图片: ${imagePath}`);
        }
      } catch (fileErr) {
        console.error('删除宠物图片文件失败:', fileErr.message);
        // 继续删除宠物记录，即使图片删除失败
      }
    }

    // 从数据库中删除宠物记录
    try {
      const success = await Pet.delete(req.params.id);
      
      if (success) {
        console.log(`宠物(ID=${req.params.id})删除成功`);
        return res.json({ message: '宠物已删除' });
      } else {
        console.error(`宠物(ID=${req.params.id})删除失败，可能已被删除`);
        return res.status(404).json({ message: '宠物不存在或已被删除' });
      }
    } catch (deleteErr) {
      console.error('数据库删除宠物记录失败:', deleteErr.message);
      return res.status(500).json({ message: '删除宠物失败', error: deleteErr.message });
    }
  } catch (err) {
    console.error('删除宠物时发生错误:', err.message);
    res.status(500).json({ message: '服务器错误', error: err.message });
  }
});

// @route   GET api/pets/stats/category-distribution
// @desc    获取宠物类别分布统计
// @access  公开访问
router.get('/stats/category-distribution', async (req, res) => {
  try {
    // 首先检查categories表是否存在
    const checkTableQuery = `
      SELECT COUNT(*) as count 
      FROM information_schema.tables 
      WHERE table_schema = 'pet_adoption' 
      AND table_name = 'categories'
    `;
    
    const [tables] = await pool.query(checkTableQuery);
    
    if (tables[0].count === 0) {
      // 如果表不存在，创建表并插入基础数据
      await pool.query(`
        CREATE TABLE IF NOT EXISTS categories (
          id INT PRIMARY KEY AUTO_INCREMENT,
          name VARCHAR(50) NOT NULL,
          description TEXT,
          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
        )
      `);
      
      // 插入基础数据
      await pool.query(`
        INSERT INTO categories (name, description) VALUES
        ('猫咪', '包括各种品种的猫'),
        ('狗狗', '包括各种品种的狗'),
        ('兔子', '包括各种品种的兔子'),
        ('鸟类', '包括各种观赏鸟类'),
        ('小宠物', '仓鼠、豚鼠等小型宠物')
      `);
    }
    
    // 获取类别分布数据
    const query = `
      SELECT 
        c.id,
        c.name as category_name,
        COUNT(p.id) as pet_count
      FROM categories c
      LEFT JOIN pets p ON c.id = p.category_id
      GROUP BY c.id, c.name
      ORDER BY pet_count DESC
    `;
    
    const [rows] = await pool.query(query);
    
    // 如果没有数据，返回空数组
    if (!rows || rows.length === 0) {
      return res.json([]);
    }
    
    // 转换数据格式以适应饼图需求
    const distribution = rows.map(row => ({
      name: row.category_name,
      value: row.pet_count || 0 // 确保value不为null
    }));
    
    res.json(distribution);
  } catch (err) {
    console.error('获取宠物类别分布统计失败:', err);
    res.status(500).json({ 
      message: '服务器错误',
      error: err.message 
    });
  }
});

module.exports = router; 